import type { RouteLocationNormalized, Router } from 'vue-router';

import { useRouter } from 'vue-router';
import { unref } from 'vue';

import { useMultipleTabStore } from '/@/store/modules/multipleTab';
import { useAppStore } from '/@/store/modules/app';

enum TableActionEnum {
  REFRESH,
  CLOSE_ALL,
  CLOSE_LEFT,
  CLOSE_RIGHT,
  CLOSE_OTHER,
  CLOSE_CURRENT,
  CLOSE,
}
/**
 * 封装所有有关tab页的操作
 * @param _router 路由实例
 * @returns 返回所有有关tab页的操作，封装为一个对象
 */
export function useTabs(_router?: Router) {
  const appStore = useAppStore();

  /**
   * 判断是否可以使用多标签页
   *
   * @returns {boolean} 是否显示多标签页
   * @throws {Error} 当多标签页未开启时，抛出错误提示
   */
  function canIUseTabs(): boolean {
    //是否显示多标签页
    const { show } = appStore.getMultiTabsSetting;
    if (!show) {
      throw new Error('The multi-tab page is currently not open, please open it in the settings！');
    }
    return !!show;
  }

  const tabStore = useMultipleTabStore();
  const router = _router || useRouter();

  const { currentRoute } = router;

  /**
   * 获取当前标签页
   *
   * @returns {Object} 当前标签页对象
   */
  function getCurrentTab() {
    const route = unref(currentRoute);
    return tabStore.getTabList.find((item) => item.fullPath === route.fullPath)!;
  }

  /**
   * 异步更新标签页标题
   *
   * @param {string} title - 标签页标题
   * @param {RouteLocationNormalized} tab - 目标标签页对象（可选）
   * @returns {Promise<void>}
   */
  async function updateTabTitle(title: string, tab?: RouteLocationNormalized) {
    const canIUse = canIUseTabs;
    // 判断是否可以使用多标签页
    //if (!canIUse) 使用的是函数作为条件判断时的短路逻辑。此时，会判断 canIUse 的返回值是否为 falsy 值
    //if (!canIUse()) 则是先调用函数 canIUse()，并判断函数返回值的布尔值。
    if (!canIUse) {
      return;
    }

    const targetTab = tab || getCurrentTab(); // 获取目标标签页，默认为当前标签页
    await tabStore.setTabTitle(title, targetTab); // 异步更新标签页标题
  }

  async function updateTabPath(path: string, tab?: RouteLocationNormalized) {
    const canIUse = canIUseTabs;
    if (!canIUse) {
      return;
    }
    const targetTab = tab || getCurrentTab();
    await tabStore.updateTabPath(path, targetTab);
  }

  /**
   * 处理Tab页操作的异步函数
   * @param action - Tab页操作类型
   * @param tab - 当前选项卡（可选）
   * @returns 无
   */
  async function handleTabAction(action: TableActionEnum, tab?: RouteLocationNormalized) {
    const canIUse = canIUseTabs; // 检查是否支持多标签页
    if (!canIUse) {
      // 不支持多标签页时直接返回
      return;
    }
    const currentTab = getCurrentTab(); // 获取当前选项卡
    switch (action) {
      case TableActionEnum.REFRESH: // 刷新操作
        await tabStore.refreshPage(router); // 刷新页面
        break;

      case TableActionEnum.CLOSE_ALL: // 关闭全部操作
        await tabStore.closeAllTab(router); // 关闭所有标签页
        break;

      case TableActionEnum.CLOSE_LEFT: // 关闭左侧操作
        await tabStore.closeLeftTabs(currentTab, router); // 关闭左侧标签页
        break;

      case TableActionEnum.CLOSE_RIGHT: // 关闭右侧操作
        await tabStore.closeRightTabs(currentTab, router); // 关闭右侧标签页
        break;

      case TableActionEnum.CLOSE_OTHER: // 关闭其他操作
        await tabStore.closeOtherTabs(currentTab, router); // 关闭其他标签页
        break;

      case TableActionEnum.CLOSE_CURRENT:
      case TableActionEnum.CLOSE: // 关闭当前操作或关闭操作（可选）
        await tabStore.closeTab(tab || currentTab, router); // 关闭指定标签页或当前标签页
        break;
    }
  }

  return {
    refreshPage: () => handleTabAction(TableActionEnum.REFRESH),
    closeAll: () => handleTabAction(TableActionEnum.CLOSE_ALL),
    closeLeft: () => handleTabAction(TableActionEnum.CLOSE_LEFT),
    closeRight: () => handleTabAction(TableActionEnum.CLOSE_RIGHT),
    closeOther: () => handleTabAction(TableActionEnum.CLOSE_OTHER),
    closeCurrent: () => handleTabAction(TableActionEnum.CLOSE_CURRENT),
    close: (tab?: RouteLocationNormalized) => handleTabAction(TableActionEnum.CLOSE, tab),
    setTitle: (title: string, tab?: RouteLocationNormalized) => updateTabTitle(title, tab),
    updatePath: (fullPath: string, tab?: RouteLocationNormalized) => updateTabPath(fullPath, tab),
  };
}
